home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / cocktail / cg.lha / cg / m2c / EvalC2.c < prev    next >
C/C++ Source or Header  |  1992-11-24  |  48KB  |  1,634 lines
  1. #include "SYSTEM_.h"
  2.  
  3. #ifndef DEFINITION_System
  4. #include "System.h"
  5. #endif
  6.  
  7. #ifndef DEFINITION_IO
  8. #include "IO.h"
  9. #endif
  10.  
  11. #ifndef DEFINITION_Tree
  12. #include "Tree.h"
  13. #endif
  14.  
  15. #ifndef DEFINITION_IO
  16. #include "IO.h"
  17. #endif
  18.  
  19. #ifndef DEFINITION_StringMem
  20. #include "StringMem.h"
  21. #endif
  22.  
  23. #ifndef DEFINITION_Idents
  24. #include "Idents.h"
  25. #endif
  26.  
  27. #ifndef DEFINITION_Texts
  28. #include "Texts.h"
  29. #endif
  30.  
  31. #ifndef DEFINITION_Sets
  32. #include "Sets.h"
  33. #endif
  34.  
  35. #ifndef DEFINITION_Relations
  36. #include "Relations.h"
  37. #endif
  38.  
  39. #ifndef DEFINITION_TreeC2
  40. #include "TreeC2.h"
  41. #endif
  42.  
  43. #ifndef DEFINITION_EvalC
  44. #include "EvalC.h"
  45. #endif
  46.  
  47. #ifndef DEFINITION_Tree
  48. #include "Tree.h"
  49. #endif
  50.  
  51. #ifndef DEFINITION_EvalC2
  52. #include "EvalC2.h"
  53. #endif
  54.  
  55. IO_tFile EvalC2_yyf;
  56. PROC EvalC2_Exit;
  57.  
  58. static SHORTCARD Start, Stop, Visit, ChildVisit, i, j, k;
  59. static Tree_tTree Node, Attr, Class, AttrClass, Child, Child2, ChildsClass;
  60. static CARDINAL Representative ARGS((CARDINAL i));
  61. static void GenAttribute ARGS((CARDINAL i, BOOLEAN repr));
  62. static Tree_tTree GetClass ARGS((Tree_tTree Class, Idents_tIdent Attribute));
  63. static BOOLEAN CheckUsage ARGS((BITSET Usage));
  64. static void yyAbort ARGS((CHAR yyFunction[], LONGCARD ));
  65. static BOOLEAN yyIsEqual ARGS((BYTE yya[], LONGCARD , BYTE yyb[], LONGCARD ));
  66. struct S_3 {
  67.     union {
  68.         char dummy;
  69.     } U_1;
  70. };
  71. static void TypeName ARGS((Tree_tTree t));
  72. struct S_4 {
  73.     union {
  74.         char dummy;
  75.     } U_1;
  76. };
  77. static void Forward ARGS((Tree_tTree t));
  78. struct S_5 {
  79.     union {
  80.         char dummy;
  81.     } U_1;
  82. };
  83. static void GenEvaluator ARGS((Tree_tTree t));
  84. struct S_6 {
  85.     union {
  86.         char dummy;
  87.     } U_1;
  88. };
  89. static void Generated0 ARGS((Tree_tTree t));
  90. struct S_7 {
  91.     union {
  92.         char dummy;
  93.     } U_1;
  94. };
  95. static void GenFormals1 ARGS((Tree_tTree t));
  96. struct S_8 {
  97.     union {
  98.         char dummy;
  99.     } U_1;
  100. };
  101. static void GenFormals2 ARGS((Tree_tTree t));
  102. struct S_9 {
  103.     union {
  104.         char dummy;
  105.     } U_1;
  106. };
  107. static void GenFormals3 ARGS((Tree_tTree t));
  108. struct S_10 {
  109.     union {
  110.         char dummy;
  111.     } U_1;
  112. };
  113. static void GenActualsRight ARGS((Tree_tTree t));
  114. struct S_11 {
  115.     union {
  116.         char dummy;
  117.     } U_1;
  118. };
  119. static void GenActualsLeft ARGS((Tree_tTree t));
  120. struct S_12 {
  121.     union {
  122.         char dummy;
  123.     } U_1;
  124. };
  125. static void GenTempos ARGS((Tree_tTree t));
  126. struct S_13 {
  127.     union {
  128.         char dummy;
  129.     } U_1;
  130. };
  131. static void GenTemposChildren ARGS((Tree_tTree t));
  132. struct S_14 {
  133.     union {
  134.         char dummy;
  135.     } U_1;
  136. };
  137. static void GenTemposLocal ARGS((Tree_tTree t));
  138. struct S_15 {
  139.     union {
  140.         char dummy;
  141.     } U_1;
  142. };
  143. static void GenDemandProc ARGS((Tree_tTree t));
  144. struct S_16 {
  145.     union {
  146.         char dummy;
  147.     } U_1;
  148. };
  149. static void GenDemandProc2 ARGS((Tree_tTree t));
  150. struct S_17 {
  151.     union {
  152.         char dummy;
  153.     } U_1;
  154. };
  155. static void GenDemandEval ARGS((Tree_tTree t));
  156. struct S_18 {
  157.     union {
  158.         char dummy;
  159.     } U_1;
  160. };
  161. static void yyExit ARGS(());
  162.  
  163.  
  164. static CARDINAL Representative
  165. # ifdef __STDC__
  166. (CARDINAL i)
  167. # else
  168. (i)
  169. CARDINAL i;
  170. # endif
  171. {
  172.   Sets_tSet s;
  173.   CARDINAL r;
  174.   BOOLEAN Stable;
  175.   CARDINAL j, k;
  176.  
  177.   {
  178.     register Tree_yClass *W_1 = &Class->U_1.V_5.Class;
  179.  
  180.     Sets_MakeSet(&s, (LONGCARD)W_1->InstCount);
  181.     Sets_Include(&s, i);
  182.     do {
  183.       Stable = TRUE;
  184.       {
  185.         LONGCARD B_1 = 1, B_2 = W_1->InstCount;
  186.  
  187.         if (B_1 <= B_2)
  188.           for (j = B_1;; j += 1) {
  189.             if (Sets_IsElement(j, &s)) {
  190.               if (IN(Tree_CopyDef, W_1->Instance->A[j - 1].Properties)) {
  191.                 k = W_1->Instance->A[j - 1].CopyArg;
  192.                 if (IN(Tree_Parameter, W_1->Instance->A[k - 1].Attribute->U_1.V_10.Attribute.Properties) && !Sets_IsElement(k, &s)) {
  193.                   Sets_Include(&s, k);
  194.                   Stable = FALSE;
  195.                 }
  196.               }
  197.               if (IN(Tree_CopyUse, W_1->Instance->A[j - 1].Properties)) {
  198.                 {
  199.                   LONGCARD B_3 = 1, B_4 = W_1->InstCount;
  200.  
  201.                   if (B_3 <= B_4)
  202.                     for (k = B_3;; k += 1) {
  203.                       if (IN(Tree_CopyDef, W_1->Instance->A[k - 1].Properties) && IN(Tree_Parameter, W_1->Instance->A[k - 1].Attribute->U_1.V_10.Attribute.Properties) && W_1->Instance->A[k - 1].CopyArg == j && !Sets_IsElement(k, &s)) {
  204.                         Sets_Include(&s, k);
  205.                         Stable = FALSE;
  206.                       }
  207.                       if (k >= B_4) break;
  208.                     }
  209.                 }
  210.               }
  211.             }
  212.             if (j >= B_2) break;
  213.           }
  214.       }
  215.     } while (!Stable);
  216.     r = Sets_Minimum(&s);
  217.     if (r <= W_1->AttrCount) {
  218.       Stable = TRUE;
  219.       j = r + 1;
  220.       for (;;) {
  221.         if (j > W_1->AttrCount) {
  222.           goto EXIT_1;
  223.         }
  224.         if (Sets_IsElement(j, &s)) {
  225.           Stable = FALSE;
  226.           goto EXIT_1;
  227.         }
  228.         INC(j);
  229.       } EXIT_1:;
  230.       if (!Stable) {
  231.         j = 1;
  232.         for (;;) {
  233.           k = W_1->Instance->A[j - 1].Order;
  234.           if (k <= W_1->AttrCount && Sets_IsElement(k, &s)) {
  235.             r = k;
  236.             goto EXIT_2;
  237.           }
  238.           INC(j);
  239.         } EXIT_2:;
  240.       }
  241.     }
  242.     Sets_ReleaseSet(&s);
  243.     return r;
  244.   }
  245. }
  246.  
  247. static void GenAttribute
  248. # ifdef __STDC__
  249. (CARDINAL i, BOOLEAN repr)
  250. # else
  251. (i, repr)
  252. CARDINAL i;
  253. BOOLEAN repr;
  254. # endif
  255. {
  256.   if (repr) {
  257.     {
  258.       register Tree_tInstance *W_2 = &Class->U_1.V_5.Class.Instance->A[i - 1];
  259.  
  260.       if (IN(Tree_Parameter, W_2->Attribute->U_1.V_10.Attribute.Properties) && ((SET_ELEM(Tree_CopyDef) | SET_ELEM(Tree_CopyUse)) & W_2->Properties) != 0X0L) {
  261.         i = Representative(i);
  262.       }
  263.     }
  264.   }
  265.   {
  266.     register Tree_tInstance *W_3 = &Class->U_1.V_5.Class.Instance->A[i - 1];
  267.  
  268.     if (IN(Tree_Virtual, W_3->Properties)) {
  269.       return;
  270.     }
  271.     if (IN(Tree_Left, W_3->Properties)) {
  272.       {
  273.         register Tree_yAttribute *W_4 = &W_3->Attribute->U_1.V_10.Attribute;
  274.  
  275.         if (IN(Tree_Parameter, W_4->Properties)) {
  276.           if (Tree_IdentifyAttribute(Node, W_4->Name) == Tree_NoTree) {
  277.             IO_WriteS(Tree_f, (STRING)"yy", 2L);
  278.             Tree_WI(W_4->Name);
  279.           } else {
  280.             IO_WriteS(Tree_f, (STRING)"(* yy", 5L);
  281.             Tree_WI(W_4->Name);
  282.             IO_WriteS(Tree_f, (STRING)")", 1L);
  283.           }
  284.         } else if (IN(Tree_Demand, W_4->Properties)) {
  285.           if (IN(Tree_Funct, W_4->Properties)) {
  286.             AttrClass = GetClass(Class, W_4->Name);
  287.             IO_WriteS(Tree_f, (STRING)"y", 1L);
  288.             Tree_WI(AttrClass->U_1.V_5.Class.Name);
  289.             IO_WriteS(Tree_f, (STRING)"y", 1L);
  290.             Tree_WI(W_4->Name);
  291.             IO_WriteS(Tree_f, (STRING)" (yyt)", 6L);
  292.           } else if (i != k) {
  293.             IO_WriteS(Tree_f, (STRING)"yy", 2L);
  294.             Tree_WI(W_4->Name);
  295.           } else {
  296.             IO_WriteS(Tree_f, (STRING)"(* yy", 5L);
  297.             Tree_WI(W_4->Name);
  298.             IO_WriteS(Tree_f, (STRING)")", 1L);
  299.           }
  300.         } else {
  301.           IO_WriteS(Tree_f, (STRING)"yyt->", 5L);
  302.           Tree_WI(Class->U_1.V_5.Class.Name);
  303.           IO_WriteS(Tree_f, (STRING)".", 1L);
  304.           Tree_WI(W_4->Name);
  305.         }
  306.       }
  307.     } else {
  308.       {
  309.         register Tree_yAttribute *W_5 = &W_3->Attribute->U_1.V_10.Attribute;
  310.  
  311.         if (IN(Tree_Parameter, W_5->Properties)) {
  312.           Tree_WI(W_3->Selector->U_1.V_9.Child.Name);
  313.           IO_WriteS(Tree_f, (STRING)"yy", 2L);
  314.           Tree_WI(W_5->Name);
  315.         } else if (IN(Tree_Demand, W_5->Properties)) {
  316.           if (IN(Tree_Funct, W_5->Properties)) {
  317.             AttrClass = GetClass(W_3->Selector->U_1.V_9.Child.Class, W_5->Name);
  318.             IO_WriteS(Tree_f, (STRING)"y", 1L);
  319.             Tree_WI(AttrClass->U_1.V_5.Class.Name);
  320.             IO_WriteS(Tree_f, (STRING)"y", 1L);
  321.             Tree_WI(W_5->Name);
  322.             IO_WriteS(Tree_f, (STRING)" (yyt->", 7L);
  323.             Tree_WI(Class->U_1.V_5.Class.Name);
  324.             IO_WriteS(Tree_f, (STRING)".", 1L);
  325.             Tree_WI(W_3->Selector->U_1.V_9.Child.Name);
  326.             IO_WriteS(Tree_f, (STRING)")", 1L);
  327.           } else {
  328.             Tree_WI(W_3->Selector->U_1.V_9.Child.Name);
  329.             IO_WriteS(Tree_f, (STRING)"yy", 2L);
  330.             Tree_WI(W_5->Name);
  331.           }
  332.         } else {
  333.           IO_WriteS(Tree_f, (STRING)"yyt->", 5L);
  334.           Tree_WI(Class->U_1.V_5.Class.Name);
  335.           IO_WriteS(Tree_f, (STRING)".", 1L);
  336.           Tree_WI(W_3->Selector->U_1.V_9.Child.Name);
  337.           IO_WriteS(Tree_f, (STRING)"->", 2L);
  338.           Tree_WI(W_3->Selector->U_1.V_9.Child.Type);
  339.           IO_WriteS(Tree_f, (STRING)".", 1L);
  340.           Tree_WI(W_5->Name);
  341.         }
  342.       }
  343.     }
  344.   }
  345. }
  346.  
  347. static Tree_tTree GetClass
  348. # ifdef __STDC__
  349. (Tree_tTree Class, Idents_tIdent Attribute)
  350. # else
  351. (Class, Attribute)
  352. Tree_tTree Class;
  353. Idents_tIdent Attribute;
  354. # endif
  355. {
  356.   while (Class->U_1.V_1.Kind != Tree_NoClass) {
  357.     if (Tree_IdentifyAttribute(Class->U_1.V_5.Class.Attributes, Attribute) != Tree_NoTree) {
  358.       return Class;
  359.     }
  360.     Class = Class->U_1.V_5.Class.BaseClass;
  361.   }
  362.   return Tree_NoTree;
  363. }
  364.  
  365. static BOOLEAN CheckUsage
  366. # ifdef __STDC__
  367. (BITSET Usage)
  368. # else
  369. (Usage)
  370. BITSET Usage;
  371. # endif
  372. {
  373.   SHORTCARD i, i2;
  374.  
  375.   {
  376.     SHORTCARD B_5 = Start, B_6 = Stop;
  377.  
  378.     if (B_5 <= B_6)
  379.       for (i = B_5;; i += 1) {
  380.         i2 = Class->U_1.V_5.Class.Instance->A[i - 1].Order;
  381.         {
  382.           register Tree_tInstance *W_6 = &Class->U_1.V_5.Class.Instance->A[i2 - 1];
  383.  
  384.           if (SET_IS_SUBSET1(SET_ELEM(Tree_Synthesized) | SET_ELEM(Tree_Right) | SET_ELEM(Tree_First), W_6->Properties) && Child == W_6->Selector && W_6->Attribute->U_1.V_9.Child.Partition <= W_6->Selector->U_1.V_9.Child.Class->U_1.V_5.Class.Visits && IN(W_6->Attribute->U_1.V_9.Child.Partition, Usage)) {
  385.             return TRUE;
  386.           }
  387.           if (SET_IS_SUBSET1(SET_ELEM(Tree_Inherited) | SET_ELEM(Tree_Right), W_6->Properties) && i2 == j) {
  388.             return TRUE;
  389.           }
  390.         }
  391.         if (i >= B_6) break;
  392.       }
  393.   }
  394.   return FALSE;
  395. }
  396.  
  397. static void yyAbort
  398. # ifdef __STDC__
  399. (CHAR yyFunction[], LONGCARD O_1)
  400. # else
  401. (yyFunction, O_1)
  402. CHAR yyFunction[];
  403. LONGCARD O_1;
  404. # endif
  405. {
  406.   OPEN_ARRAY_LOCALS
  407.  
  408.   ALLOC_OPEN_ARRAYS(O_1 * sizeof(CHAR), 1)
  409.   COPY_OPEN_ARRAY(yyFunction, O_1, CHAR)
  410.   IO_WriteS((System_tFile)IO_StdError, (STRING)"Error: module EvalC2, routine ", 30L);
  411.   IO_WriteS((System_tFile)IO_StdError, yyFunction, O_1);
  412.   IO_WriteS((System_tFile)IO_StdError, (STRING)" failed", 7L);
  413.   IO_WriteNl((System_tFile)IO_StdError);
  414.   (*EvalC2_Exit)();
  415.   FREE_OPEN_ARRAYS
  416. }
  417.  
  418. static BOOLEAN yyIsEqual
  419. # ifdef __STDC__
  420. (BYTE yya[], LONGCARD O_3, BYTE yyb[], LONGCARD O_2)
  421. # else
  422. (yya, O_3, yyb, O_2)
  423. BYTE yya[];
  424. LONGCARD O_3;
  425. BYTE yyb[];
  426. LONGCARD O_2;
  427. # endif
  428. {
  429.   INTEGER yyi;
  430.   OPEN_ARRAY_LOCALS
  431.  
  432.   ALLOC_OPEN_ARRAYS(O_2 * sizeof(WORD) + O_3 * sizeof(WORD), 2)
  433.   COPY_OPEN_ARRAY(yyb, O_2, WORD)
  434.   COPY_OPEN_ARRAY(yya, O_3, WORD)
  435.   {
  436.     LONGINT B_7 = 0, B_8 = (INTEGER)(O_3 - 1);
  437.  
  438.     if (B_7 <= B_8)
  439.       for (yyi = B_7;; yyi += 1) {
  440.         if (yya[yyi] != yyb[yyi]) {
  441.           FREE_OPEN_ARRAYS
  442.           return FALSE;
  443.         }
  444.         if (yyi >= B_8) break;
  445.       }
  446.   }
  447.   FREE_OPEN_ARRAYS
  448.   return TRUE;
  449. }
  450.  
  451. void EvalC2_EvalImplC
  452. # ifdef __STDC__
  453. (Tree_tTree t)
  454. # else
  455. (t)
  456. Tree_tTree t;
  457. # endif
  458. {
  459.   struct S_3 yyTempo;
  460.  
  461.   if (t == Tree_NoTree) {
  462.     return;
  463.   }
  464.   if (t->U_1.V_1.Kind == Tree_Ag) {
  465.     {
  466.       register Tree_yAg *W_7 = &t->U_1.V_26.Ag;
  467.  
  468.       EvalC_EvalImplHead(t);
  469.       IO_WriteNl(Tree_f);
  470.       Tree_ForallClasses(W_7->Classes, (Tree_ProcOfT)Forward);
  471.       IO_WriteNl(Tree_f);
  472.       IO_WriteS(Tree_f, (STRING)"void ", 5L);
  473.       Tree_WI(W_7->EvalName);
  474.       IO_WriteNl(Tree_f);
  475.       IO_WriteS(Tree_f, (STRING)"# if defined __STDC__ | defined __cplusplus", 43L);
  476.       IO_WriteNl(Tree_f);
  477.       IO_WriteS(Tree_f, (STRING)" (", 2L);
  478.       Tree_WI(Tree_itTree);
  479.       IO_WriteS(Tree_f, (STRING)" yyt)", 5L);
  480.       IO_WriteNl(Tree_f);
  481.       IO_WriteS(Tree_f, (STRING)"# else", 6L);
  482.       IO_WriteNl(Tree_f);
  483.       IO_WriteS(Tree_f, (STRING)" (yyt) ", 7L);
  484.       Tree_WI(Tree_itTree);
  485.       IO_WriteS(Tree_f, (STRING)" yyt;", 5L);
  486.       IO_WriteNl(Tree_f);
  487.       IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  488.       IO_WriteNl(Tree_f);
  489.       Node = W_7->Classes;
  490.       Class = W_7->Classes;
  491.       IO_WriteS(Tree_f, (STRING)"{", 1L);
  492.       IO_WriteNl(Tree_f);
  493.       Tree_ForallAttributes(Class, (Tree_ProcOfT)GenTemposLocal);
  494.       if (!Sets_IsElement(ORD('9'), &Tree_Options)) {
  495.         if (Tree_MaxVisit > 0) {
  496.           Class = W_7->Classes;
  497.           Visit = 1;
  498.           IO_WriteS(Tree_f, (STRING)" yyVisit1", 9L);
  499.           Tree_WI(Class->U_1.V_5.Class.Name);
  500.           IO_WriteS(Tree_f, (STRING)" (yyt", 5L);
  501.           Tree_ForallAttributes(Class, (Tree_ProcOfT)GenActualsLeft);
  502.           IO_WriteS(Tree_f, (STRING)");", 2L);
  503.         }
  504.         IO_WriteS(Tree_f, (STRING)" }", 2L);
  505.         IO_WriteNl(Tree_f);
  506.       } else {
  507.         IO_WriteS(Tree_f, (STRING)" char xxHigh;", 13L);
  508.         IO_WriteNl(Tree_f);
  509.         IO_WriteS(Tree_f, (STRING)" xxStack = 1000000000;", 22L);
  510.         IO_WriteNl(Tree_f);
  511.         if (Tree_MaxVisit > 0) {
  512.           Class = W_7->Classes;
  513.           Visit = 1;
  514.           IO_WriteS(Tree_f, (STRING)" yyVisit1", 9L);
  515.           Tree_WI(Class->U_1.V_5.Class.Name);
  516.           IO_WriteS(Tree_f, (STRING)" (yyt", 5L);
  517.           Tree_ForallAttributes(Class, (Tree_ProcOfT)GenActualsLeft);
  518.           IO_WriteS(Tree_f, (STRING)");", 2L);
  519.           IO_WriteNl(Tree_f);
  520.         }
  521.         IO_WriteS(Tree_f, (STRING)" (void) printf (\"Stacksize %d\\n\", (int) & xxHigh - xxStack);", 60L);
  522.         IO_WriteNl(Tree_f);
  523.         IO_WriteS(Tree_f, (STRING)"}", 1L);
  524.         IO_WriteNl(Tree_f);
  525.       }
  526.       IO_WriteNl(Tree_f);
  527.       Tree_ForallClasses(W_7->Classes, (Tree_ProcOfT)GenDemandProc);
  528.       Tree_ForallClasses(W_7->Classes, (Tree_ProcOfT)EvalC2_EvalImplC);
  529.       IO_WriteS(Tree_f, (STRING)"void Begin", 10L);
  530.       Tree_WI(W_7->EvalName);
  531.       IO_WriteS(Tree_f, (STRING)" ()", 3L);
  532.       IO_WriteNl(Tree_f);
  533.       IO_WriteS(Tree_f, (STRING)"{", 1L);
  534.       IO_WriteNl(Tree_f);
  535.       TreeC2_WriteLine(W_7->EvalCodes->U_1.V_12.Codes.BeginLine);
  536.       Texts_WriteText(Tree_f, W_7->EvalCodes->U_1.V_12.Codes.Begin);
  537.       Node = W_7->Modules;
  538.       while (Node->U_1.V_1.Kind == Tree_Module) {
  539.         TreeC2_WriteLine(Node->U_1.V_43.Module.EvalCodes->U_1.V_12.Codes.BeginLine);
  540.         Texts_WriteText(Tree_f, Node->U_1.V_43.Module.EvalCodes->U_1.V_12.Codes.Begin);
  541.         Node = Node->U_1.V_43.Module.Next;
  542.       }
  543.       IO_WriteS(Tree_f, (STRING)"}", 1L);
  544.       IO_WriteNl(Tree_f);
  545.       IO_WriteNl(Tree_f);
  546.       IO_WriteS(Tree_f, (STRING)"void Close", 10L);
  547.       Tree_WI(W_7->EvalName);
  548.       IO_WriteS(Tree_f, (STRING)" ()", 3L);
  549.       IO_WriteNl(Tree_f);
  550.       IO_WriteS(Tree_f, (STRING)"{", 1L);
  551.       IO_WriteNl(Tree_f);
  552.       TreeC2_WriteLine(W_7->EvalCodes->U_1.V_12.Codes.CloseLine);
  553.       Texts_WriteText(Tree_f, W_7->EvalCodes->U_1.V_12.Codes.Close);
  554.       Node = W_7->Modules;
  555.       while (Node->U_1.V_1.Kind == Tree_Module) {
  556.         TreeC2_WriteLine(Node->U_1.V_43.Module.EvalCodes->U_1.V_12.Codes.CloseLine);
  557.         Texts_WriteText(Tree_f, Node->U_1.V_43.Module.EvalCodes->U_1.V_12.Codes.Close);
  558.         Node = Node->U_1.V_43.Module.Next;
  559.       }
  560.       IO_WriteS(Tree_f, (STRING)"}", 1L);
  561.       IO_WriteNl(Tree_f);
  562.       return;
  563.     }
  564.   }
  565.   if (t->U_1.V_1.Kind == Tree_Class) {
  566.     {
  567.       register Tree_yClass *W_8 = &t->U_1.V_5.Class;
  568.  
  569.       if ((Tree_NoCodeClass & W_8->Properties) != 0X0L) {
  570.         return;
  571.       }
  572.       if (IN(Tree_Referenced, W_8->Properties)) {
  573.         W_8->Generated = 0;
  574.         Tree_ForallClasses(W_8->Extensions, (Tree_ProcOfT)Generated0);
  575.         {
  576.           SHORTCARD B_9 = 1, B_10 = W_8->Visits;
  577.  
  578.           if (B_9 <= B_10)
  579.             for (Visit = B_9;; Visit += 1) {
  580.               Node = t;
  581.               Class = t;
  582.               IO_WriteS(Tree_f, (STRING)"static void yyVisit", 19L);
  583.               Tree_WN((LONGINT)Visit);
  584.               Tree_WI(W_8->Name);
  585.               IO_WriteNl(Tree_f);
  586.               IO_WriteS(Tree_f, (STRING)"# if defined __STDC__ | defined __cplusplus", 43L);
  587.               IO_WriteNl(Tree_f);
  588.               IO_WriteS(Tree_f, (STRING)" (register ", 11L);
  589.               Tree_WI(Tree_itTree);
  590.               IO_WriteS(Tree_f, (STRING)" yyt", 4L);
  591.               Tree_ForallAttributes(t, (Tree_ProcOfT)GenFormals3);
  592.               IO_WriteS(Tree_f, (STRING)")", 1L);
  593.               IO_WriteNl(Tree_f);
  594.               IO_WriteS(Tree_f, (STRING)"# else", 6L);
  595.               IO_WriteNl(Tree_f);
  596.               IO_WriteS(Tree_f, (STRING)" (yyt", 5L);
  597.               Tree_ForallAttributes(t, (Tree_ProcOfT)GenFormals1);
  598.               IO_WriteS(Tree_f, (STRING)")", 1L);
  599.               IO_WriteNl(Tree_f);
  600.               IO_WriteS(Tree_f, (STRING)" register ", 10L);
  601.               Tree_WI(Tree_itTree);
  602.               IO_WriteS(Tree_f, (STRING)" yyt;", 5L);
  603.               IO_WriteNl(Tree_f);
  604.               Tree_ForallAttributes(t, (Tree_ProcOfT)GenFormals2);
  605.               IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  606.               IO_WriteNl(Tree_f);
  607.               IO_WriteS(Tree_f, (STRING)"{", 1L);
  608.               IO_WriteNl(Tree_f);
  609.               TreeC2_WriteLine(Tree_TreeRoot->U_1.V_26.Ag.EvalCodes->U_1.V_12.Codes.LocalLine);
  610.               Texts_WriteText(Tree_f, Tree_TreeRoot->U_1.V_26.Ag.EvalCodes->U_1.V_12.Codes.Local);
  611.               Node = Tree_TreeRoot->U_1.V_26.Ag.Modules;
  612.               while (Node->U_1.V_1.Kind == Tree_Module) {
  613.                 TreeC2_WriteLine(Node->U_1.V_43.Module.EvalCodes->U_1.V_12.Codes.LocalLine);
  614.                 Texts_WriteText(Tree_f, Node->U_1.V_43.Module.EvalCodes->U_1.V_12.Codes.Local);
  615.                 Node = Node->U_1.V_43.Module.Next;
  616.               }
  617.               if (Sets_IsElement(ORD('9'), &Tree_Options)) {
  618.                 IO_WriteS(Tree_f, (STRING)" char xxLow;", 12L);
  619.                 IO_WriteNl(Tree_f);
  620.                 IO_WriteS(Tree_f, (STRING)" xxStack = Min (xxStack, (int) & xxLow);", 40L);
  621.                 IO_WriteNl(Tree_f);
  622.               }
  623.               IO_WriteS(Tree_f, (STRING)" switch (yyt->Kind) {", 21L);
  624.               IO_WriteNl(Tree_f);
  625.               if (IN(Tree_cOAG, Tree_GrammarClass)) {
  626.                 Node = t;
  627.                 GenEvaluator(t);
  628.                 Tree_ForallClasses(W_8->Extensions, (Tree_ProcOfT)GenEvaluator);
  629.               }
  630.               IO_WriteS(Tree_f, (STRING)" default: ;", 11L);
  631.               IO_WriteNl(Tree_f);
  632.               if (Sets_IsElement(ORD('Z'), &Tree_Options)) {
  633.                 IO_WriteS(Tree_f, (STRING)"  yyVisitParent (yyt);", 22L);
  634.                 IO_WriteNl(Tree_f);
  635.               }
  636.               IO_WriteS(Tree_f, (STRING)" }", 2L);
  637.               IO_WriteNl(Tree_f);
  638.               IO_WriteS(Tree_f, (STRING)"}", 1L);
  639.               IO_WriteNl(Tree_f);
  640.               IO_WriteNl(Tree_f);
  641.               if (Visit >= B_10) break;
  642.             }
  643.         }
  644.       }
  645.       return;
  646.     }
  647.   }
  648. }
  649.  
  650. static void TypeName
  651. # ifdef __STDC__
  652. (Tree_tTree t)
  653. # else
  654. (t)
  655. Tree_tTree t;
  656. # endif
  657. {
  658.   struct S_4 yyTempo;
  659.  
  660.   if (t == Tree_NoTree) {
  661.     return;
  662.   }
  663.   if (t->U_1.V_1.Kind == Tree_Class) {
  664.     {
  665.       register Tree_yClass *W_9 = &t->U_1.V_5.Class;
  666.  
  667.       if ((Tree_NoCodeClass & W_9->Properties) != 0X0L) {
  668.         return;
  669.       }
  670.       if (IN(Tree_Trace, W_9->Properties)) {
  671.         IO_WriteS(Tree_f, (STRING)"\"", 1L);
  672.         Tree_WI(W_9->Name);
  673.         IO_WriteS(Tree_f, (STRING)"\",", 2L);
  674.         IO_WriteNl(Tree_f);
  675.       }
  676.       return;
  677.     }
  678.   }
  679. }
  680.  
  681. static void Forward
  682. # ifdef __STDC__
  683. (Tree_tTree t)
  684. # else
  685. (t)
  686. Tree_tTree t;
  687. # endif
  688. {
  689.   struct S_5 yyTempo;
  690.  
  691.   if (t == Tree_NoTree) {
  692.     return;
  693.   }
  694.   if (t->U_1.V_1.Kind == Tree_Class) {
  695.     {
  696.       register Tree_yClass *W_10 = &t->U_1.V_5.Class;
  697.  
  698.       if ((Tree_NoCodeClass & W_10->Properties) != 0X0L) {
  699.         return;
  700.       }
  701.       if (IN(Tree_Referenced, W_10->Properties)) {
  702.         {
  703.           SHORTCARD B_11 = 1, B_12 = W_10->Visits;
  704.  
  705.           if (B_11 <= B_12)
  706.             for (Visit = B_11;; Visit += 1) {
  707.               IO_WriteS(Tree_f, (STRING)"static void yyVisit", 19L);
  708.               Tree_WN((LONGINT)Visit);
  709.               Tree_WI(W_10->Name);
  710.               IO_WriteS(Tree_f, (STRING)" ARGS((register ", 16L);
  711.               Tree_WI(Tree_itTree);
  712.               IO_WriteS(Tree_f, (STRING)" yyt", 4L);
  713.               Node = t;
  714.               Class = t;
  715.               Tree_ForallAttributes(t, (Tree_ProcOfT)Forward);
  716.               IO_WriteS(Tree_f, (STRING)"));", 3L);
  717.               IO_WriteNl(Tree_f);
  718.               if (Visit >= B_12) break;
  719.             }
  720.         }
  721.       }
  722.       return;
  723.     }
  724.   }
  725.   if (t->U_1.V_1.Kind == Tree_Attribute) {
  726.     {
  727.       register Tree_yAttribute *W_11 = &t->U_1.V_10.Attribute;
  728.  
  729.       if (IN(Tree_Parameter, W_11->Properties) && IN(Visit, W_11->Usage)) {
  730.         IO_WriteS(Tree_f, (STRING)", ", 2L);
  731.         Tree_WI(W_11->Type);
  732.         IO_WriteS(Tree_f, (STRING)" ", 1L);
  733.         GenAttribute((LONGCARD)W_11->AttrIndex, FALSE);
  734.       }
  735.       return;
  736.     }
  737.   }
  738. }
  739.  
  740. static void GenEvaluator
  741. # ifdef __STDC__
  742. (Tree_tTree t)
  743. # else
  744. (t)
  745. Tree_tTree t;
  746. # endif
  747. {
  748.   struct S_6 yyTempo;
  749.  
  750.   if (t == Tree_NoTree) {
  751.     return;
  752.   }
  753.   switch (t->U_1.V_1.Kind) {
  754.   case Tree_Class:;
  755.     {
  756.       register Tree_yClass *W_12 = &t->U_1.V_5.Class;
  757.  
  758.       if ((Tree_NoCodeClass & W_12->Properties) != 0X0L) {
  759.         return;
  760.       }
  761.       if (W_12->Generated == W_12->InstCount) {
  762.         return;
  763.       }
  764.       IO_WriteS(Tree_f, (STRING)"case k", 6L);
  765.       Tree_WI(W_12->Name);
  766.       IO_WriteS(Tree_f, (STRING)": {", 3L);
  767.       IO_WriteNl(Tree_f);
  768.       Start = W_12->Generated + 1;
  769.       for (;;) {
  770.         if (W_12->Generated == W_12->InstCount) {
  771.           goto EXIT_3;
  772.         }
  773.         INC(W_12->Generated);
  774.         {
  775.           register Tree_tInstance *W_13 = &W_12->Instance->A[W_12->Instance->A[W_12->Generated - 1].Order - 1];
  776.  
  777.           if (IN(Tree_Left, W_13->Properties) && W_13->Attribute->U_1.V_9.Child.Partition > Visit) {
  778.             DEC(W_12->Generated);
  779.             goto EXIT_3;
  780.           }
  781.         }
  782.       } EXIT_3:;
  783.       Stop = W_12->Generated;
  784.       Class = t;
  785.       Tree_ForallAttributes(t, (Tree_ProcOfT)GenTempos);
  786.       {
  787.         SHORTCARD B_13 = Start, B_14 = Stop;
  788.  
  789.         if (B_13 <= B_14)
  790.           for (Start = B_13;; Start += 1) {
  791.             i = W_12->Instance->A[Start - 1].Order;
  792.             {
  793.               register Tree_tInstance *W_14 = &W_12->Instance->A[i - 1];
  794.  
  795.               if (SET_IS_SUBSET1(SET_ELEM(Tree_Inherited) | SET_ELEM(Tree_Right) | SET_ELEM(Tree_First), W_14->Properties) && ((SET_ELEM(Tree_Dummy) | SET_ELEM(Tree_Virtual) | SET_ELEM(Tree_Demand)) & W_14->Properties) == 0X0L) {
  796.                 GenDemandEval(t);
  797.                 if (Sets_IsElement(ORD('X'), &Tree_Options) && IN(Tree_Trace, t->U_1.V_5.Class.Properties)) {
  798.                   IO_WriteS(Tree_f, (STRING)"yyWriteEval (yyt, \"", 19L);
  799.                   Tree_WI(W_14->Selector->U_1.V_9.Child.Name);
  800.                   IO_WriteS(Tree_f, (STRING)":", 1L);
  801.                   Tree_WI(W_14->Attribute->U_1.V_9.Child.Name);
  802.                   IO_WriteS(Tree_f, (STRING)"\");", 3L);
  803.                   IO_WriteNl(Tree_f);
  804.                   if (W_14->Action != ADR(W_14->Action)) {
  805.                     GenEvaluator(W_14->Action);
  806.                   }
  807.                   IO_WriteNl(Tree_f);
  808.                   if (W_14->Attribute->U_1.V_1.Kind == Tree_Child || W_14->Attribute->U_1.V_10.Attribute.Type == Tree_itTree) {
  809.                     IO_WriteS(Tree_f, (STRING)"write", 5L);
  810.                     Tree_WI(Tree_itTree);
  811.                     IO_WriteS(Tree_f, (STRING)" (", 2L);
  812.                     GenAttribute((LONGCARD)i, TRUE);
  813.                     IO_WriteS(Tree_f, (STRING)")", 1L);
  814.                     IO_WriteNl(Tree_f);
  815.                   } else {
  816.                     IO_WriteS(Tree_f, (STRING)"write", 5L);
  817.                     Tree_WI(W_14->Attribute->U_1.V_9.Child.Type);
  818.                     IO_WriteS(Tree_f, (STRING)" (", 2L);
  819.                     GenAttribute((LONGCARD)i, TRUE);
  820.                     IO_WriteS(Tree_f, (STRING)") yyWriteNl ();", 15L);
  821.                     IO_WriteNl(Tree_f);
  822.                   }
  823.                 } else if (Sets_IsElement(ORD('Y'), &Tree_Options) && IN(Tree_Trace, t->U_1.V_5.Class.Properties)) {
  824.                   IO_WriteS(Tree_f, (STRING)"yyWriteEval (yyt, \"", 19L);
  825.                   Tree_WI(W_14->Selector->U_1.V_9.Child.Name);
  826.                   IO_WriteS(Tree_f, (STRING)":", 1L);
  827.                   Tree_WI(W_14->Attribute->U_1.V_9.Child.Name);
  828.                   IO_WriteS(Tree_f, (STRING)"\");", 3L);
  829.                   IO_WriteNl(Tree_f);
  830.                   if (W_14->Action != ADR(W_14->Action)) {
  831.                     GenEvaluator(W_14->Action);
  832.                   }
  833.                 } else {
  834.                   if (W_14->Action != ADR(W_14->Action)) {
  835.                     GenEvaluator(W_14->Action);
  836.                   }
  837.                 }
  838.               }
  839.               if (SET_IS_SUBSET1(SET_ELEM(Tree_Synthesized) | SET_ELEM(Tree_Left) | SET_ELEM(Tree_First), W_14->Properties) && ((SET_ELEM(Tree_Dummy) | SET_ELEM(Tree_Virtual) | SET_ELEM(Tree_Demand)) & W_14->Properties) == 0X0L) {
  840.                 GenDemandEval(t);
  841.                 if (Sets_IsElement(ORD('X'), &Tree_Options) && IN(Tree_Trace, t->U_1.V_5.Class.Properties)) {
  842.                   IO_WriteS(Tree_f, (STRING)"yyWriteEval (yyt, \"", 19L);
  843.                   Tree_WI(W_14->Attribute->U_1.V_9.Child.Name);
  844.                   IO_WriteS(Tree_f, (STRING)"\");", 3L);
  845.                   IO_WriteNl(Tree_f);
  846.                   if (W_14->Action != ADR(W_14->Action)) {
  847.                     GenEvaluator(W_14->Action);
  848.                   }
  849.                   IO_WriteNl(Tree_f);
  850.                   if (IN(Tree_Test, W_14->Properties)) {
  851.                     IO_WriteS(Tree_f, (STRING)"writebool (yyb) yyWriteNl ();", 29L);
  852.                     IO_WriteNl(Tree_f);
  853.                   } else if (W_14->Attribute->U_1.V_1.Kind == Tree_Child || W_14->Attribute->U_1.V_10.Attribute.Type == Tree_itTree) {
  854.                     IO_WriteS(Tree_f, (STRING)"write", 5L);
  855.                     Tree_WI(Tree_itTree);
  856.                     IO_WriteS(Tree_f, (STRING)" (", 2L);
  857.                     GenAttribute((LONGCARD)i, TRUE);
  858.                     IO_WriteS(Tree_f, (STRING)")", 1L);
  859.                     IO_WriteNl(Tree_f);
  860.                   } else {
  861.                     IO_WriteS(Tree_f, (STRING)"write", 5L);
  862.                     Tree_WI(W_14->Attribute->U_1.V_9.Child.Type);
  863.                     IO_WriteS(Tree_f, (STRING)" (", 2L);
  864.                     GenAttribute((LONGCARD)i, TRUE);
  865.                     IO_WriteS(Tree_f, (STRING)") yyWriteNl ();", 15L);
  866.                     IO_WriteNl(Tree_f);
  867.                   }
  868.                 } else if (Sets_IsElement(ORD('Y'), &Tree_Options) && IN(Tree_Trace, t->U_1.V_5.Class.Properties)) {
  869.                   IO_WriteS(Tree_f, (STRING)"yyWriteEval (yyt, \"", 19L);
  870.                   Tree_WI(W_14->Attribute->U_1.V_9.Child.Name);
  871.                   IO_WriteS(Tree_f, (STRING)"\");", 3L);
  872.                   IO_WriteNl(Tree_f);
  873.                   if (W_14->Action != ADR(W_14->Action)) {
  874.                     GenEvaluator(W_14->Action);
  875.                   }
  876.                 } else {
  877.                   if (W_14->Action != ADR(W_14->Action)) {
  878.                     GenEvaluator(W_14->Action);
  879.                   }
  880.                 }
  881.               }
  882.               if (SET_IS_SUBSET1(SET_ELEM(Tree_Synthesized) | SET_ELEM(Tree_Right) | SET_ELEM(Tree_First), W_14->Properties) && W_14->Attribute->U_1.V_9.Child.Partition <= W_14->Selector->U_1.V_9.Child.Class->U_1.V_5.Class.Visits) {
  883.                 if (Sets_IsElement(ORD('Z'), &Tree_Options) && IN(Tree_Trace, t->U_1.V_5.Class.Properties)) {
  884.                   IO_WriteS(Tree_f, (STRING)"yyWriteVisit (yyt, \"", 20L);
  885.                   Tree_WI(W_14->Selector->U_1.V_9.Child.Name);
  886.                   IO_WriteS(Tree_f, (STRING)" ", 1L);
  887.                   Tree_WN((LONGINT)W_14->Attribute->U_1.V_9.Child.Partition);
  888.                   IO_WriteS(Tree_f, (STRING)"\");", 3L);
  889.                   IO_WriteNl(Tree_f);
  890.                 }
  891.                 ChildVisit = W_14->Attribute->U_1.V_9.Child.Partition;
  892.                 Child = W_14->Selector;
  893.                 IO_WriteS(Tree_f, (STRING)"yyVisit", 7L);
  894.                 Tree_WN((LONGINT)ChildVisit);
  895.                 Tree_WI(Child->U_1.V_9.Child.Type);
  896.                 IO_WriteS(Tree_f, (STRING)" (yyt->", 7L);
  897.                 Tree_WI(W_12->Name);
  898.                 IO_WriteS(Tree_f, (STRING)".", 1L);
  899.                 Tree_WI(Child->U_1.V_9.Child.Name);
  900.                 Tree_ForallAttributes(Child->U_1.V_9.Child.Class, (Tree_ProcOfT)GenActualsRight);
  901.                 IO_WriteS(Tree_f, (STRING)");", 2L);
  902.                 IO_WriteNl(Tree_f);
  903.               }
  904.             }
  905.             if (Start >= B_14) break;
  906.           }
  907.       }
  908.       if (Sets_IsElement(ORD('Z'), &Tree_Options) && IN(Tree_Trace, t->U_1.V_5.Class.Properties)) {
  909.         IO_WriteS(Tree_f, (STRING)"yyVisitParent (yyt);", 20L);
  910.         IO_WriteNl(Tree_f);
  911.       }
  912.       IO_WriteS(Tree_f, (STRING)"} break;", 8L);
  913.       IO_WriteNl(Tree_f);
  914.       return;
  915.     }
  916.     break;
  917.   case Tree_Assign:;
  918.     {
  919.       register Tree_yAssign *W_15 = &t->U_1.V_36.Assign;
  920.  
  921.       TreeC2_WriteLine(W_15->Pos);
  922.       GenEvaluator(W_15->Results);
  923.       IO_WriteS(Tree_f, (STRING)"=", 1L);
  924.       GenEvaluator(W_15->Arguments);
  925.       IO_WriteS(Tree_f, (STRING)";", 1L);
  926.       IO_WriteNl(Tree_f);
  927.       return;
  928.     }
  929.     break;
  930.   case Tree_Copy:;
  931.     {
  932.       register Tree_yCopy *W_16 = &t->U_1.V_37.Copy;
  933.  
  934.       j = Class->U_1.V_5.Class.Instance->A[i - 1].CopyArg;
  935.       if (IN(Tree_Parameter, Class->U_1.V_5.Class.Instance->A[i - 1].Attribute->U_1.V_10.Attribute.Properties) && IN(Tree_Parameter, Class->U_1.V_5.Class.Instance->A[j - 1].Attribute->U_1.V_10.Attribute.Properties)) {
  936.         if (IN(Tree_Left, Class->U_1.V_5.Class.Instance->A[i - 1].Properties) && IN(Tree_Left, Class->U_1.V_5.Class.Instance->A[j - 1].Properties)) {
  937.           TreeC2_WriteLine(W_16->Pos);
  938.           GenAttribute((LONGCARD)i, FALSE);
  939.           IO_WriteS(Tree_f, (STRING)" =", 2L);
  940.           GenEvaluator(W_16->Arguments);
  941.           IO_WriteS(Tree_f, (STRING)";", 1L);
  942.           IO_WriteNl(Tree_f);
  943.         }
  944.       } else {
  945.         TreeC2_WriteLine(W_16->Pos);
  946.         GenEvaluator(W_16->Results);
  947.         IO_WriteS(Tree_f, (STRING)"=", 1L);
  948.         GenEvaluator(W_16->Arguments);
  949.         IO_WriteS(Tree_f, (STRING)";", 1L);
  950.         IO_WriteNl(Tree_f);
  951.       }
  952.       return;
  953.     }
  954.     break;
  955.   case Tree_TargetCode:;
  956.     {
  957.       register Tree_yTargetCode *W_17 = &t->U_1.V_38.TargetCode;
  958.  
  959.       TreeC2_WriteLine(W_17->Pos);
  960.       GenEvaluator(W_17->Code);
  961.       IO_WriteNl(Tree_f);
  962.       return;
  963.     }
  964.     break;
  965.   case Tree_Check:;
  966.     {
  967.       register Tree_yCheck *W_18 = &t->U_1.V_40.Check;
  968.  
  969.       TreeC2_WriteLine(W_18->Pos);
  970.       if (W_18->Condition != Tree_NoTree) {
  971.         IO_WriteS(Tree_f, (STRING)"if (! (", 7L);
  972.         if (Sets_IsElement(ORD('X'), &Tree_Options)) {
  973.           IO_WriteS(Tree_f, (STRING)"yyb = ", 6L);
  974.         }
  975.         GenEvaluator(W_18->Condition);
  976.         IO_WriteS(Tree_f, (STRING)")) {", 4L);
  977.         GenEvaluator(W_18->Statement);
  978.         IO_WriteS(Tree_f, (STRING)"; }", 3L);
  979.         IO_WriteNl(Tree_f);
  980.         if (W_18->Actions->U_1.V_1.Kind == Tree_Check) {
  981.           IO_WriteS(Tree_f, (STRING)"else ", 5L);
  982.           GenEvaluator(W_18->Actions);
  983.         }
  984.       } else {
  985.         if (Sets_IsElement(ORD('X'), &Tree_Options)) {
  986.           IO_WriteS(Tree_f, (STRING)"yyb = false; ", 13L);
  987.         }
  988.         GenEvaluator(W_18->Statement);
  989.         IO_WriteS(Tree_f, (STRING)";", 1L);
  990.         IO_WriteNl(Tree_f);
  991.         GenEvaluator(W_18->Actions);
  992.       }
  993.       return;
  994.     }
  995.     break;
  996.   case Tree_Designator:;
  997.     {
  998.       register Tree_yDesignator *W_19 = &t->U_1.V_15.Designator;
  999.  
  1000.       Child2 = Tree_IdentifyAttribute(Class, W_19->Selector);
  1001.       if (Child2 != Tree_NoTree) {
  1002.         ChildsClass = Child2->U_1.V_9.Child.Class;
  1003.         Attr = Tree_IdentifyAttribute(ChildsClass, W_19->Attribute);
  1004.         if (Attr != Tree_NoTree) {
  1005.           GenAttribute((LONGCARD)(Class->U_1.V_5.Class.AttrCount + Child2->U_1.V_9.Child.InstOffset + Attr->U_1.V_10.Attribute.AttrIndex), TRUE);
  1006.         } else {
  1007.           Tree_WI(W_19->Selector);
  1008.           IO_WriteS(Tree_f, (STRING)":", 1L);
  1009.           Tree_WI(W_19->Attribute);
  1010.         }
  1011.       } else {
  1012.         Tree_WI(W_19->Selector);
  1013.         IO_WriteS(Tree_f, (STRING)":", 1L);
  1014.         Tree_WI(W_19->Attribute);
  1015.       }
  1016.       GenEvaluator(W_19->Next);
  1017.       return;
  1018.     }
  1019.     break;
  1020.   case Tree_Ident:;
  1021.     {
  1022.       register Tree_yIdent *W_20 = &t->U_1.V_16.Ident;
  1023.  
  1024.       Attr = Tree_IdentifyAttribute(Class, W_20->Attribute);
  1025.       if (Attr != Tree_NoTree) {
  1026.         GenAttribute((LONGCARD)Attr->U_1.V_10.Attribute.AttrIndex, TRUE);
  1027.       } else {
  1028.         Tree_WI(W_20->Attribute);
  1029.       }
  1030.       GenEvaluator(W_20->Next);
  1031.       return;
  1032.     }
  1033.     break;
  1034.   case Tree_Any:;
  1035.     {
  1036.       register Tree_yAny *W_21 = &t->U_1.V_18.Any;
  1037.  
  1038.       StringMem_WriteString(Tree_f, W_21->Code);
  1039.       GenEvaluator(W_21->Next);
  1040.       return;
  1041.     }
  1042.     break;
  1043.   case Tree_Anys:;
  1044.     {
  1045.       register Tree_yAnys *W_22 = &t->U_1.V_19.Anys;
  1046.  
  1047.       GenEvaluator(W_22->Layouts);
  1048.       GenEvaluator(W_22->Next);
  1049.       return;
  1050.     }
  1051.     break;
  1052.   case Tree_LayoutAny:;
  1053.     {
  1054.       register Tree_yLayoutAny *W_23 = &t->U_1.V_22.LayoutAny;
  1055.  
  1056.       StringMem_WriteString(Tree_f, W_23->Code);
  1057.       GenEvaluator(W_23->Next);
  1058.       return;
  1059.     }
  1060.     break;
  1061.   default :
  1062.     break;
  1063.   }
  1064. }
  1065.  
  1066. static void Generated0
  1067. # ifdef __STDC__
  1068. (Tree_tTree t)
  1069. # else
  1070. (t)
  1071. Tree_tTree t;
  1072. # endif
  1073. {
  1074.   struct S_7 yyTempo;
  1075.  
  1076.   if (t == Tree_NoTree) {
  1077.     return;
  1078.   }
  1079.   if (t->U_1.V_1.Kind == Tree_Class) {
  1080.     {
  1081.       register Tree_yClass *W_24 = &t->U_1.V_5.Class;
  1082.  
  1083.       W_24->Generated = 0;
  1084.       return;
  1085.     }
  1086.   }
  1087. }
  1088.  
  1089. static void GenFormals1
  1090. # ifdef __STDC__
  1091. (Tree_tTree t)
  1092. # else
  1093. (t)
  1094. Tree_tTree t;
  1095. # endif
  1096. {
  1097.   struct S_8 yyTempo;
  1098.  
  1099.   if (t == Tree_NoTree) {
  1100.     return;
  1101.   }
  1102.   if (t->U_1.V_1.Kind == Tree_Attribute) {
  1103.     {
  1104.       register Tree_yAttribute *W_25 = &t->U_1.V_10.Attribute;
  1105.  
  1106.       if (IN(Tree_Parameter, W_25->Properties) && IN(Visit, W_25->Usage)) {
  1107.         IO_WriteS(Tree_f, (STRING)", yy", 4L);
  1108.         Tree_WI(W_25->Name);
  1109.       }
  1110.       return;
  1111.     }
  1112.   }
  1113. }
  1114.  
  1115. static void GenFormals2
  1116. # ifdef __STDC__
  1117. (Tree_tTree t)
  1118. # else
  1119. (t)
  1120. Tree_tTree t;
  1121. # endif
  1122. {
  1123.   struct S_9 yyTempo;
  1124.  
  1125.   if (t == Tree_NoTree) {
  1126.     return;
  1127.   }
  1128.   if (t->U_1.V_1.Kind == Tree_Attribute) {
  1129.     {
  1130.       register Tree_yAttribute *W_26 = &t->U_1.V_10.Attribute;
  1131.  
  1132.       if (IN(Tree_Parameter, W_26->Properties) && IN(Visit, W_26->Usage)) {
  1133.         IO_WriteS(Tree_f, (STRING)" ", 1L);
  1134.         Tree_WI(W_26->Type);
  1135.         IO_WriteS(Tree_f, (STRING)" ", 1L);
  1136.         GenAttribute((LONGCARD)W_26->AttrIndex, FALSE);
  1137.         IO_WriteS(Tree_f, (STRING)";", 1L);
  1138.         IO_WriteNl(Tree_f);
  1139.       }
  1140.       return;
  1141.     }
  1142.   }
  1143. }
  1144.  
  1145. static void GenFormals3
  1146. # ifdef __STDC__
  1147. (Tree_tTree t)
  1148. # else
  1149. (t)
  1150. Tree_tTree t;
  1151. # endif
  1152. {
  1153.   struct S_10 yyTempo;
  1154.  
  1155.   if (t == Tree_NoTree) {
  1156.     return;
  1157.   }
  1158.   if (t->U_1.V_1.Kind == Tree_Attribute) {
  1159.     {
  1160.       register Tree_yAttribute *W_27 = &t->U_1.V_10.Attribute;
  1161.  
  1162.       if (IN(Tree_Parameter, W_27->Properties) && IN(Visit, W_27->Usage)) {
  1163.         IO_WriteS(Tree_f, (STRING)" ,", 2L);
  1164.         Tree_WI(W_27->Type);
  1165.         IO_WriteS(Tree_f, (STRING)" ", 1L);
  1166.         GenAttribute((LONGCARD)W_27->AttrIndex, FALSE);
  1167.       }
  1168.       return;
  1169.     }
  1170.   }
  1171. }
  1172.  
  1173. static void GenActualsRight
  1174. # ifdef __STDC__
  1175. (Tree_tTree t)
  1176. # else
  1177. (t)
  1178. Tree_tTree t;
  1179. # endif
  1180. {
  1181.   struct S_11 yyTempo;
  1182.  
  1183.   if (t == Tree_NoTree) {
  1184.     return;
  1185.   }
  1186.   if (t->U_1.V_1.Kind == Tree_Attribute) {
  1187.     {
  1188.       register Tree_yAttribute *W_28 = &t->U_1.V_10.Attribute;
  1189.  
  1190.       if (IN(Tree_Parameter, W_28->Properties) && IN(ChildVisit, W_28->Usage)) {
  1191.         IO_WriteS(Tree_f, (STRING)", & ", 4L);
  1192.         GenAttribute((LONGCARD)(Class->U_1.V_5.Class.AttrCount + Child->U_1.V_9.Child.InstOffset + W_28->AttrIndex), TRUE);
  1193.       }
  1194.       return;
  1195.     }
  1196.   }
  1197. }
  1198.  
  1199. static void GenActualsLeft
  1200. # ifdef __STDC__
  1201. (Tree_tTree t)
  1202. # else
  1203. (t)
  1204. Tree_tTree t;
  1205. # endif
  1206. {
  1207.   struct S_12 yyTempo;
  1208.  
  1209.   if (t == Tree_NoTree) {
  1210.     return;
  1211.   }
  1212.   if (t->U_1.V_1.Kind == Tree_Attribute) {
  1213.     {
  1214.       register Tree_yAttribute *W_29 = &t->U_1.V_10.Attribute;
  1215.  
  1216.       if (IN(Tree_Parameter, W_29->Properties) && IN(Visit, W_29->Usage)) {
  1217.         IO_WriteS(Tree_f, (STRING)", ", 2L);
  1218.         GenAttribute((LONGCARD)W_29->AttrIndex, FALSE);
  1219.       }
  1220.       return;
  1221.     }
  1222.   }
  1223. }
  1224.  
  1225. static void GenTempos
  1226. # ifdef __STDC__
  1227. (Tree_tTree t)
  1228. # else
  1229. (t)
  1230. Tree_tTree t;
  1231. # endif
  1232. {
  1233.   struct S_13 yyTempo;
  1234.  
  1235.   if (t == Tree_NoTree) {
  1236.     return;
  1237.   }
  1238.   if (t->U_1.V_1.Kind == Tree_Child) {
  1239.     {
  1240.       register Tree_yChild *W_30 = &t->U_1.V_9.Child;
  1241.  
  1242.       Child = t;
  1243.       Tree_ForallAttributes(W_30->Class, (Tree_ProcOfT)GenTemposChildren);
  1244.       return;
  1245.     }
  1246.   }
  1247.   if (t->U_1.V_1.Kind == Tree_Attribute) {
  1248.     {
  1249.       register Tree_yAttribute *W_31 = &t->U_1.V_10.Attribute;
  1250.  
  1251.       if (IN(Tree_Parameter, W_31->Properties) && Tree_IdentifyAttribute(Node, W_31->Name) == Tree_NoTree && IN(Visit, W_31->Usage) || IN(Tree_Demand, W_31->Properties) && !IN(Tree_Funct, W_31->Properties) && W_31->AttrIndex != k) {
  1252.         Tree_WI(W_31->Type);
  1253.         IO_WriteS(Tree_f, (STRING)" yy", 3L);
  1254.         Tree_WI(W_31->Name);
  1255.         IO_WriteS(Tree_f, (STRING)";", 1L);
  1256.         IO_WriteNl(Tree_f);
  1257.       }
  1258.       return;
  1259.     }
  1260.   }
  1261. }
  1262.  
  1263. static void GenTemposChildren
  1264. # ifdef __STDC__
  1265. (Tree_tTree t)
  1266. # else
  1267. (t)
  1268. Tree_tTree t;
  1269. # endif
  1270. {
  1271.   struct S_14 yyTempo;
  1272.  
  1273.   if (t == Tree_NoTree) {
  1274.     return;
  1275.   }
  1276.   if (t->U_1.V_1.Kind == Tree_Attribute) {
  1277.     {
  1278.       register Tree_yAttribute *W_32 = &t->U_1.V_10.Attribute;
  1279.  
  1280.       if (IN(Tree_Parameter, W_32->Properties) || IN(Tree_Demand, W_32->Properties) && !IN(Tree_Funct, W_32->Properties)) {
  1281.         j = Class->U_1.V_5.Class.AttrCount + Child->U_1.V_9.Child.InstOffset + W_32->AttrIndex;
  1282.         if (IN(Tree_Demand, W_32->Properties) || ((SET_ELEM(Tree_CopyDef) | SET_ELEM(Tree_CopyUse)) & Class->U_1.V_5.Class.Instance->A[j - 1].Properties) == 0X0L || j == Representative((LONGCARD)j)) {
  1283.           if (CheckUsage(W_32->Usage)) {
  1284.             Tree_WI(W_32->Type);
  1285.             IO_WriteS(Tree_f, (STRING)" ", 1L);
  1286.             Tree_WI(Child->U_1.V_9.Child.Name);
  1287.             IO_WriteS(Tree_f, (STRING)"yy", 2L);
  1288.             Tree_WI(W_32->Name);
  1289.             IO_WriteS(Tree_f, (STRING)";", 1L);
  1290.             IO_WriteNl(Tree_f);
  1291.           }
  1292.         }
  1293.       }
  1294.       return;
  1295.     }
  1296.   }
  1297. }
  1298.  
  1299. static void GenTemposLocal
  1300. # ifdef __STDC__
  1301. (Tree_tTree t)
  1302. # else
  1303. (t)
  1304. Tree_tTree t;
  1305. # endif
  1306. {
  1307.   struct S_15 yyTempo;
  1308.  
  1309.   if (t == Tree_NoTree) {
  1310.     return;
  1311.   }
  1312.   if (t->U_1.V_1.Kind == Tree_Attribute) {
  1313.     {
  1314.       register Tree_yAttribute *W_33 = &t->U_1.V_10.Attribute;
  1315.  
  1316.       if (IN(Tree_Parameter, W_33->Properties)) {
  1317.         IO_WriteS(Tree_f, (STRING)"  ", 2L);
  1318.         Tree_WI(W_33->Type);
  1319.         IO_WriteS(Tree_f, (STRING)" ", 1L);
  1320.         GenAttribute((LONGCARD)W_33->AttrIndex, FALSE);
  1321.         IO_WriteS(Tree_f, (STRING)";", 1L);
  1322.         IO_WriteNl(Tree_f);
  1323.       }
  1324.       return;
  1325.     }
  1326.   }
  1327. }
  1328.  
  1329. static void GenDemandProc
  1330. # ifdef __STDC__
  1331. (Tree_tTree t)
  1332. # else
  1333. (t)
  1334. Tree_tTree t;
  1335. # endif
  1336. {
  1337.   struct S_16 yyTempo;
  1338.  
  1339.   if (t == Tree_NoTree) {
  1340.     return;
  1341.   }
  1342.   if (t->U_1.V_1.Kind == Tree_Class) {
  1343.     {
  1344.       register Tree_yClass *W_34 = &t->U_1.V_5.Class;
  1345.  
  1346.       if ((Tree_NoCodeClass & W_34->Properties) != 0X0L) {
  1347.         return;
  1348.       }
  1349.       Node = t;
  1350.       Tree_ForallAttributes(W_34->Attributes, (Tree_ProcOfT)GenDemandProc);
  1351.       return;
  1352.     }
  1353.   }
  1354.   if (t->U_1.V_1.Kind == Tree_Attribute) {
  1355.     {
  1356.       register Tree_yAttribute *W_35 = &t->U_1.V_10.Attribute;
  1357.  
  1358.       if (IN(Tree_Demand, W_35->Properties)) {
  1359.         Class = Node;
  1360.         k = W_35->AttrIndex;
  1361.         if (IN(Tree_Funct, W_35->Properties)) {
  1362.           IO_WriteS(Tree_f, (STRING)"static ", 7L);
  1363.           Tree_WI(W_35->Type);
  1364.           IO_WriteS(Tree_f, (STRING)" y", 2L);
  1365.           Tree_WI(Class->U_1.V_5.Class.Name);
  1366.           IO_WriteS(Tree_f, (STRING)"y", 1L);
  1367.           Tree_WI(W_35->Name);
  1368.           IO_WriteNl(Tree_f);
  1369.           IO_WriteS(Tree_f, (STRING)"# if defined __STDC__ | defined __cplusplus", 43L);
  1370.           IO_WriteNl(Tree_f);
  1371.           IO_WriteS(Tree_f, (STRING)" (register ", 11L);
  1372.           Tree_WI(Tree_itTree);
  1373.           IO_WriteS(Tree_f, (STRING)" yyt)", 5L);
  1374.           IO_WriteNl(Tree_f);
  1375.           IO_WriteS(Tree_f, (STRING)"# else", 6L);
  1376.           IO_WriteNl(Tree_f);
  1377.           IO_WriteS(Tree_f, (STRING)" (yyt) register ", 16L);
  1378.           Tree_WI(Tree_itTree);
  1379.           IO_WriteS(Tree_f, (STRING)" yyt;", 5L);
  1380.           IO_WriteNl(Tree_f);
  1381.           IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  1382.           IO_WriteNl(Tree_f);
  1383.         } else {
  1384.           IO_WriteS(Tree_f, (STRING)"static void y", 13L);
  1385.           Tree_WI(Class->U_1.V_5.Class.Name);
  1386.           IO_WriteS(Tree_f, (STRING)"y", 1L);
  1387.           Tree_WI(W_35->Name);
  1388.           IO_WriteNl(Tree_f);
  1389.           IO_WriteS(Tree_f, (STRING)"# if defined __STDC__ | defined __cplusplus", 43L);
  1390.           IO_WriteNl(Tree_f);
  1391.           IO_WriteS(Tree_f, (STRING)" (register ", 11L);
  1392.           Tree_WI(Tree_itTree);
  1393.           IO_WriteS(Tree_f, (STRING)" yyt, ", 6L);
  1394.           Tree_WI(W_35->Type);
  1395.           IO_WriteS(Tree_f, (STRING)" * ", 3L);
  1396.           GenAttribute((LONGCARD)W_35->AttrIndex, FALSE);
  1397.           IO_WriteS(Tree_f, (STRING)")", 1L);
  1398.           IO_WriteNl(Tree_f);
  1399.           IO_WriteS(Tree_f, (STRING)"# else", 6L);
  1400.           IO_WriteNl(Tree_f);
  1401.           IO_WriteS(Tree_f, (STRING)" (yyt, ", 7L);
  1402.           GenAttribute((LONGCARD)W_35->AttrIndex, FALSE);
  1403.           IO_WriteS(Tree_f, (STRING)")", 1L);
  1404.           IO_WriteNl(Tree_f);
  1405.           IO_WriteS(Tree_f, (STRING)" register ", 10L);
  1406.           Tree_WI(Tree_itTree);
  1407.           IO_WriteS(Tree_f, (STRING)" yyt;", 5L);
  1408.           IO_WriteNl(Tree_f);
  1409.           IO_WriteS(Tree_f, (STRING)" ", 1L);
  1410.           Tree_WI(W_35->Type);
  1411.           IO_WriteS(Tree_f, (STRING)" * ", 3L);
  1412.           GenAttribute((LONGCARD)W_35->AttrIndex, FALSE);
  1413.           IO_WriteS(Tree_f, (STRING)";", 1L);
  1414.           IO_WriteNl(Tree_f);
  1415.           IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  1416.           IO_WriteNl(Tree_f);
  1417.         }
  1418.         IO_WriteS(Tree_f, (STRING)"{", 1L);
  1419.         IO_WriteNl(Tree_f);
  1420.         IO_WriteS(Tree_f, (STRING)" switch (yyt->Kind) {", 21L);
  1421.         IO_WriteNl(Tree_f);
  1422.         if (IN(Tree_cOAG, Tree_GrammarClass)) {
  1423.           i = W_35->AttrIndex;
  1424.           Class = Node;
  1425.           Visit = W_35->Partition;
  1426.           GenDemandProc2(Class);
  1427.           Tree_ForallClasses(Class->U_1.V_5.Class.Extensions, (Tree_ProcOfT)GenDemandProc2);
  1428.           Class = Node;
  1429.         }
  1430.         IO_WriteS(Tree_f, (STRING)" default: ;", 11L);
  1431.         IO_WriteNl(Tree_f);
  1432.         IO_WriteS(Tree_f, (STRING)" }", 2L);
  1433.         IO_WriteNl(Tree_f);
  1434.         IO_WriteS(Tree_f, (STRING)"}", 1L);
  1435.         IO_WriteNl(Tree_f);
  1436.         IO_WriteNl(Tree_f);
  1437.         k = 0;
  1438.       }
  1439.       return;
  1440.     }
  1441.   }
  1442. }
  1443.  
  1444. static void GenDemandProc2
  1445. # ifdef __STDC__
  1446. (Tree_tTree t)
  1447. # else
  1448. (t)
  1449. Tree_tTree t;
  1450. # endif
  1451. {
  1452.   struct S_17 yyTempo;
  1453.  
  1454.   if (t == Tree_NoTree) {
  1455.     return;
  1456.   }
  1457.   if (t->U_1.V_1.Kind == Tree_Class) {
  1458.     {
  1459.       register Tree_yClass *W_36 = &t->U_1.V_5.Class;
  1460.  
  1461.       IO_WriteS(Tree_f, (STRING)"case k", 6L);
  1462.       Tree_WI(W_36->Name);
  1463.       IO_WriteS(Tree_f, (STRING)": {", 3L);
  1464.       IO_WriteNl(Tree_f);
  1465.       {
  1466.         register Tree_tInstance *W_37 = &W_36->Instance->A[i - 1];
  1467.  
  1468.         Class = t;
  1469.         Tree_ForallAttributes(t, (Tree_ProcOfT)GenTempos);
  1470.         GenDemandEval(t);
  1471.         if (IN(Tree_Funct, W_37->Properties)) {
  1472.           GenDemandProc2(W_37->Action);
  1473.         } else {
  1474.           GenEvaluator(W_37->Action);
  1475.           IO_WriteNl(Tree_f);
  1476.         }
  1477.       }
  1478.       IO_WriteS(Tree_f, (STRING)"} break;", 8L);
  1479.       IO_WriteNl(Tree_f);
  1480.       return;
  1481.     }
  1482.   }
  1483.   if (t->U_1.V_1.Kind == Tree_Assign) {
  1484.     {
  1485.       register Tree_yAssign *W_38 = &t->U_1.V_36.Assign;
  1486.  
  1487.       IO_WriteS(Tree_f, (STRING)"return ", 7L);
  1488.       GenEvaluator(W_38->Arguments);
  1489.       IO_WriteS(Tree_f, (STRING)";", 1L);
  1490.       IO_WriteNl(Tree_f);
  1491.       return;
  1492.     }
  1493.   }
  1494.   if (t->U_1.V_1.Kind == Tree_Copy) {
  1495.     {
  1496.       register Tree_yCopy *W_39 = &t->U_1.V_37.Copy;
  1497.  
  1498.       IO_WriteS(Tree_f, (STRING)"return ", 7L);
  1499.       GenEvaluator(W_39->Arguments);
  1500.       IO_WriteS(Tree_f, (STRING)";", 1L);
  1501.       IO_WriteNl(Tree_f);
  1502.       return;
  1503.     }
  1504.   }
  1505.   if (t->U_1.V_1.Kind == Tree_TargetCode) {
  1506.     {
  1507.       register Tree_yTargetCode *W_40 = &t->U_1.V_38.TargetCode;
  1508.  
  1509.       IO_WriteS(Tree_f, (STRING)"NoBlockStatementForDemandFunctionAttributes;", 44L);
  1510.       IO_WriteNl(Tree_f);
  1511.       return;
  1512.     }
  1513.   }
  1514. }
  1515.  
  1516. static void GenDemandEval
  1517. # ifdef __STDC__
  1518. (Tree_tTree t)
  1519. # else
  1520. (t)
  1521. Tree_tTree t;
  1522. # endif
  1523. {
  1524.   struct S_18 yyTempo;
  1525.  
  1526.   if (t == Tree_NoTree) {
  1527.     return;
  1528.   }
  1529.   if (t->U_1.V_1.Kind == Tree_Class) {
  1530.     {
  1531.       register Tree_yClass *W_41 = &t->U_1.V_5.Class;
  1532.  
  1533.       {
  1534.         SHORTCARD B_15 = 1, B_16 = W_41->InstCount;
  1535.  
  1536.         if (B_15 <= B_16)
  1537.           for (j = B_15;; j += 1) {
  1538.             {
  1539.               register Tree_tInstance *W_42 = &W_41->Instance->A[j - 1];
  1540.  
  1541.               if (Relations_IsRelated((LONGINT)i, (LONGINT)j, W_41->DP) && IN(Tree_Demand, W_42->Properties) && !IN(Tree_Funct, W_42->Properties)) {
  1542.                 if (IN(Tree_Left, W_42->Properties)) {
  1543.                   AttrClass = GetClass(t, W_42->Attribute->U_1.V_9.Child.Name);
  1544.                   IO_WriteS(Tree_f, (STRING)"    y", 5L);
  1545.                   Tree_WI(AttrClass->U_1.V_5.Class.Name);
  1546.                   IO_WriteS(Tree_f, (STRING)"y", 1L);
  1547.                   Tree_WI(W_42->Attribute->U_1.V_9.Child.Name);
  1548.                   IO_WriteS(Tree_f, (STRING)" (yyt, ", 7L);
  1549.                   GenAttribute((LONGCARD)j, FALSE);
  1550.                   IO_WriteS(Tree_f, (STRING)");", 2L);
  1551.                   IO_WriteNl(Tree_f);
  1552.                 } else {
  1553.                   AttrClass = GetClass(W_42->Selector->U_1.V_9.Child.Class, W_42->Attribute->U_1.V_9.Child.Name);
  1554.                   IO_WriteS(Tree_f, (STRING)"    y", 5L);
  1555.                   Tree_WI(AttrClass->U_1.V_5.Class.Name);
  1556.                   IO_WriteS(Tree_f, (STRING)"y", 1L);
  1557.                   Tree_WI(W_42->Attribute->U_1.V_9.Child.Name);
  1558.                   IO_WriteS(Tree_f, (STRING)" (yyt->", 7L);
  1559.                   Tree_WI(W_41->Name);
  1560.                   IO_WriteS(Tree_f, (STRING)".", 1L);
  1561.                   Tree_WI(W_42->Selector->U_1.V_9.Child.Name);
  1562.                   IO_WriteS(Tree_f, (STRING)", ", 2L);
  1563.                   GenAttribute((LONGCARD)j, FALSE);
  1564.                   IO_WriteS(Tree_f, (STRING)");", 2L);
  1565.                   IO_WriteNl(Tree_f);
  1566.                 }
  1567.               }
  1568.             }
  1569.             if (j >= B_16) break;
  1570.           }
  1571.       }
  1572.       return;
  1573.     }
  1574.   }
  1575. }
  1576.  
  1577. void EvalC2_BeginEvalC2
  1578. # ifdef __STDC__
  1579. ()
  1580. # else
  1581. ()
  1582. # endif
  1583. {
  1584.   k = 0;
  1585. }
  1586.  
  1587. void EvalC2_CloseEvalC2
  1588. # ifdef __STDC__
  1589. ()
  1590. # else
  1591. ()
  1592. # endif
  1593. {
  1594. }
  1595.  
  1596. static void yyExit
  1597. # ifdef __STDC__
  1598. ()
  1599. # else
  1600. ()
  1601. # endif
  1602. {
  1603.   IO_CloseIO();
  1604.   Exit(1L);
  1605. }
  1606.  
  1607. void BEGIN_EvalC2()
  1608. {
  1609.   static BOOLEAN has_been_called = FALSE;
  1610.  
  1611.   if (!has_been_called) {
  1612.     has_been_called = TRUE;
  1613.  
  1614.     BEGIN_IO();
  1615.     BEGIN_Tree();
  1616.     BEGIN_System();
  1617.     BEGIN_IO();
  1618.     BEGIN_Tree();
  1619.     BEGIN_IO();
  1620.     BEGIN_StringMem();
  1621.     BEGIN_Idents();
  1622.     BEGIN_Texts();
  1623.     BEGIN_Sets();
  1624.     BEGIN_Relations();
  1625.     BEGIN_TreeC2();
  1626.     BEGIN_EvalC();
  1627.     BEGIN_Tree();
  1628.  
  1629.     EvalC2_yyf = IO_StdOutput;
  1630.     EvalC2_Exit = yyExit;
  1631.     EvalC2_BeginEvalC2();
  1632.   }
  1633. }
  1634.